Please address the comments from this code review:

## Overall Comments
- Both in `actionInvoked` and `doActionInvoked` the asynchronous `XdgActivation` flow can indefinitely delay emitting `ActionInvoked`/`NotificationClosed` or starting `dde-am` if `tokenReady` is never emitted; consider adding an error/timeout path or a fallback that proceeds without a token.
- You unconditionally create a new `XdgActivation` instance for every action, which may be unnecessary on non-Wayland sessions and could add overhead; consider guarding this logic with a Wayland/session check or reusing a shared helper instead of allocating per-action.
- The `XdgActivation` setup and cleanup code is duplicated in two places; consider extracting a small helper (e.g., `requestActivationToken(callback)`) to centralize token acquisition and ensure consistent behavior and resource management.

## Individual Comments

### Comment 1
<location path="panels/notification/server/notificationmanager.cpp" line_range="139" />
<code_context>
-    Q_EMIT ActionInvoked(bubbleId, actionKey);
-    Q_EMIT NotificationClosed(bubbleId, NotifyEntity::Closed);
+    // For non-extended actions, emit ActivationToken first if available
+    auto *activation = new DS_NAMESPACE::XdgActivation(this);
+    connect(activation, &DS_NAMESPACE::XdgActivation::tokenReady, this,
+        [this, bubbleId, actionKey, activation](const QString &token) {
</code_context>
<issue_to_address>
**issue (complexity):** Consider extracting the repeated XdgActivation setup into a reusable helper that takes a handler functor to simplify control flow and avoid duplication in both call sites.

The `XdgActivation` usage is duplicated and adds nested lambdas and lifetime handling in both call sites. Extracting a small helper that owns `XdgActivation` and just calls a functor when the token is ready will keep both sites linear and remove the extra `amArgsCopy`.

Example helper (private method in `NotificationManager`):

```c++
class NotificationManager : public QObject
{
    Q_OBJECT
    // ...
private:
    template <typename F>
    void withActivationToken(F &&handler)
    {
        auto *activation = new DS_NAMESPACE::XdgActivation(this);
        connect(activation, &DS_NAMESPACE::XdgActivation::tokenReady, this,
                [activation, handler = std::forward<F>(handler)](const QString &token) mutable {
                    handler(token);
                    activation->deleteLater();
                },
                Qt::SingleShotConnection);
        activation->requestToken();
    }
};
```

Then `actionInvoked` becomes simpler and closer to the original structure:

```c++
void NotificationManager::actionInvoked(qint64 id, uint bubbleId, const QString &actionKey)
{
    qInfo(notifyLog) << "Action invoked, bubbleId:" << bubbleId << ", id:" << id << ", actionKey" << actionKey;
    actionInvoked(id, actionKey);

    withActivationToken([this, bubbleId, actionKey](const QString &token) {
        if (!token.isEmpty()) {
            Q_EMIT ActivationToken(bubbleId, token);
            qDebug(notifyLog) << "Emitted ActivationToken for non-extended action:" << token;
        }
        Q_EMIT ActionInvoked(bubbleId, actionKey);
        Q_EMIT NotificationClosed(bubbleId, NotifyEntity::Closed);
    });
}
```

And the extended action (`dde-am` launch) stays linear and avoids `amArgsCopy`:

```c++
if (!args.isEmpty()) {
    QString cmd = args.takeFirst();

    QStringList amArgs;
    amArgs << "-c" << cmd;
    if (!args.isEmpty()) {
        amArgs << "--" << args;
    }

    withActivationToken([amArgs = std::move(amArgs)](const QString &token) {
        QProcess pro;
        pro.setProgram("dde-am");
        pro.setArguments(amArgs);

        QProcessEnvironment proEnv = QProcessEnvironment::systemEnvironment();
        proEnv.remove("DSG_APP_ID");

        if (!token.isEmpty()) {
            proEnv.insert("XDG_ACTIVATION_TOKEN", token);
            qDebug(notifyLog) << "Set XDG_ACTIVATION_TOKEN for extended action:" << token;
        }

        pro.setProcessEnvironment(proEnv);
        pro.startDetached();
    });
}
```

This keeps all behavior (including token emission, `ActivationToken` signal, and process environment setup) while reducing duplication, nesting, and manual `new`/`deleteLater` in the main logic.
</issue_to_address>